
#ifndef Single_h
#define Single_h

#include <System/Object.h>
#include <System/IFormattable.h>
#include <System/IConvertible.h>
#include <System/Generic/IComparable.h>
#include <System/Generic/IEquatable.h>
#include <System/Globalization/NumberStyles.h>
#include <System/DateTime.h>

#include <math.h>

namespace Riccsson
{
	namespace System
	{
		// Summary:
		//     Represents a 32-bit signed integer.
		//[Serializable]
		//[ComVisible(true)]
		struct Single
			: public Object
			//, public: IComparable
			, public IFormattable
			, public IConvertible
			, public Generic::IComparable<float>
			, public Generic::IEquatable<float>
		{
			REGISTER_CLASS(Single)

		private:
			float _internalUInt32;

			// Summary:
			//     Represents the smallest positive System.Single value that is greater than
			//     zero. This field is constant.
			public: static const float Epsilon;
			//
			// Summary:
			//     Represents the largest possible value of System.Single. This field is constant.
			public: static const float MaxValue;
			//
			// Summary:
			//     Represents the smallest possible value of System.Single. This field is constant.
			public: static const float MinValue;
			//
			// Summary:
			//     Represents not a number (NaN). This field is constant.
			public: static const float NaN; // 0.0f / 0.0f;
			//
			// Summary:
			//     Represents negative infinity. This field is constant.
			public: static const float NegativeInfinity; // -1.0f / 0.0f;
			//
			// Summary:
			//     Represents positive infinity. This field is constant.
			public: static const float PositiveInfinity; // 1.0f / 0.0f;

			// Summary:
			//     Compares this instance to a specified single-precision floating-point number
			//     and returns an integer that indicates whether the value of this instance
			//     is less than, equal to, or greater than the value of the specified single-precision
			//     floating-point number.
			//
			// Parameters:
			//   value:
			//     A single-precision floating-point number to compare.
			//
			// Returns:
			//     A signed number indicating the relative values of this instance and value.Return
			//     Value Description Less than zero This instance is less than value.-or- This
			//     instance is not a number (System.Single.NaN) and value is a number. Zero
			//     This instance is equal to value.-or- Both this instance and value are not
			//     a number (System.Single.NaN), System.Single.PositiveInfinity, or System.Single.NegativeInfinity.
			//     Greater than zero This instance is greater than value.-or- This instance
			//     is a number and value is not a number (System.Single.NaN).
			public: int CompareTo(float* value)
			{
				throw;
			}
			//
			// Summary:
			//     Compares this instance to a specified object and returns an integer that
			//     indicates whether the value of this instance is less than, equal to, or greater
			//     than the value of the specified object.
			//
			// Parameters:
			//   value:
			//     An object to compare, or null.
			//
			// Returns:
			//     A signed number indicating the relative values of this instance and value.Return
			//     Value Description Less than zero This instance is less than value.-or- This
			//     instance is not a number (System.Single.NaN) and value is a number. Zero
			//     This instance is equal to value.-or- This instance and value are both not
			//     a number (System.Single.NaN), System.Single.PositiveInfinity, or System.Single.NegativeInfinity.
			//     Greater than zero This instance is greater than value.-or- This instance
			//     is a number and value is not a number (System.Single.NaN).-or- value is null.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     value is not a System.Single.
			public: int CompareTo(object* value)
			{
				throw;
			}
			//
			// Summary:
			//     Returns a value indicating whether this instance and a specified System.Single
			//     object represent the same value.
			//
			// Parameters:
			//   obj:
			//     An object to compare with this instance.
			//
			// Returns:
			//     true if obj is equal to this instance; otherwise, false.
			public: bool Equals(float* obj)
			{
				throw;
			}
			//
			// Summary:
			//     Returns a value indicating whether this instance is equal to a specified
			//     object.
			//
			// Parameters:
			//   obj:
			//     An object to compare with this instance.
			//
			// Returns:
			//     true if obj is an instance of System.Single and equals the value of this
			//     instance; otherwise, false.
			public: override bool Equals(object* obj)
			{
				throw;
			}
			//
			// Summary:
			//     Returns the hash code for this instance.
			//
			// Returns:
			//     A 32-bit signed integer hash code.
			public: override int GetHashCode()
			{
				throw;
			}
			//
			// Summary:
			//     Returns the System.TypeCode for value type System.Single.
			//
			// Returns:
			//     The enumerated constant, System.TypeCode.Single.
			public: TypeCode GetTypeCode()
			{
				throw;
			}
			//
			// Summary:
			//     Returns a value indicating whether the specified number evaluates to negative
			//     or positive infinity.
			//
			// Parameters:
			//   f:
			//     A single-precision floating-point number.
			//
			// Returns:
			//     true if f evaluates to System.Single.PositiveInfinity or System.Single.NegativeInfinity;
			//     otherwise, false.
			public: static bool IsInfinity(float f)
			{
				throw;
			}
			//
			// Summary:
			//     Returns a value that indicates whether the specified value is not a number
			//     (System.Single.NaN).
			//
			// Parameters:
			//   f:
			//     A single-precision floating-point number.
			//
			// Returns:
			//     true if f evaluates to not a number (System.Single.NaN); otherwise, false.
			public: static bool IsNaN(float f)
			{
				throw;
			}
			//
			// Summary:
			//     Returns a value indicating whether the specified number evaluates to negative
			//     infinity.
			//
			// Parameters:
			//   f:
			//     A single-precision floating-point number.
			//
			// Returns:
			//     true if f evaluates to System.Single.NegativeInfinity; otherwise, false.
			public: static bool IsNegativeInfinity(float f)
			{
				throw;
			}
			//
			// Summary:
			//     Returns a value indicating whether the specified number evaluates to positive
			//     infinity.
			//
			// Parameters:
			//   f:
			//     A single-precision floating-point number.
			//
			// Returns:
			//     true if f evaluates to System.Single.PositiveInfinity; otherwise, false.
			public: static bool IsPositiveInfinity(float f)
			{
				throw;
			}
			//
			// Summary:
			//     Converts the string representation of a number to its single-precision floating-point
			//     number equivalent.
			//
			// Parameters:
			//   s:
			//     A string that contains a number to convert.
			//
			// Returns:
			//     A single-precision floating-point number equivalent to the numeric value
			//     or symbol specified in s.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     s is null.
			//
			//   System.FormatException:
			//     s does not represent a number in a valid format.
			//
			//   System.OverflowException:
			//     s represents a number less than System.Single.MinValue or greater than System.Single.MaxValue.
			public: static float Parse(string* s)
			{
				throw;
			}
			//
			// Summary:
			//     Converts the string representation of a number in a specified culture-specific
			//     format to its single-precision floating-point number equivalent.
			//
			// Parameters:
			//   s:
			//     A string that contains a number to convert.
			//
			//   provider:
			//     An object that supplies culture-specific formatting information about s.
			//
			// Returns:
			//     A single-precision floating-point number equivalent to the numeric value
			//     or symbol specified in s.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     s is null.
			//
			//   System.FormatException:
			//     s does not represent a number in a valid format.
			//
			//   System.OverflowException:
			//     s represents a number less than System.Single.MinValue or greater than System.Single.MaxValue.
			public: static float Parse(string* s, IFormatProvider* provider)
			{
				throw;
			}
			//
			// Summary:
			//     Converts the string representation of a number in a specified style to its
			//     single-precision floating-point number equivalent.
			//
			// Parameters:
			//   s:
			//     A string that contains a number to convert.
			//
			//   style:
			//     A bitwise combination of enumeration values that indicates the style elements
			//     that can be present in s. A typical value to specify is System.Globalization.NumberStyles.Float
			//     combined with System.Globalization.NumberStyles.AllowThousands.
			//
			// Returns:
			//     A single-precision floating-point number that is equivalent to the numeric
			//     value or symbol specified in s.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     s is null.
			//
			//   System.FormatException:
			//     s is not a number in a valid format.
			//
			//   System.OverflowException:
			//     s represents a number that is less than System.Single.MinValue or greater
			//     than System.Single.MaxValue.
			//
			//   System.ArgumentException:
			//     style is not a System.Globalization.NumberStyles value. -or-style includes
			//     the System.Globalization.NumberStyles.AllowHexSpecifier value.
			public: static float Parse(string* s, Globalization::NumberStyles* style)
			{
				throw;
			}
			//
			// Summary:
			//     Converts the string representation of a number in a specified style and culture-specific
			//     format to its single-precision floating-point number equivalent.
			//
			// Parameters:
			//   s:
			//     A string that contains a number to convert.
			//
			//   style:
			//     A bitwise combination of enumeration values that indicates the style elements
			//     that can be present in s. A typical value to specify is System.Globalization.NumberStyles.Float
			//     combined with System.Globalization.NumberStyles.AllowThousands.
			//
			//   provider:
			//     An object that supplies culture-specific formatting information about s.
			//
			// Returns:
			//     A single-precision floating-point number equivalent to the numeric value
			//     or symbol specified in s.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     s is null.
			//
			//   System.FormatException:
			//     s does not represent a numeric value.
			//
			//   System.ArgumentException:
			//     style is not a System.Globalization.NumberStyles value. -or-style is the
			//     System.Globalization.NumberStyles.AllowHexSpecifier value.
			//
			//   System.OverflowException:
			//     s represents a number that is less than System.Single.MinValue or greater
			//     than System.Single.MaxValue.
			public: static float Parse(string* s, Globalization::NumberStyles* style, IFormatProvider* provider)
			{
				throw;
			}
			//
			// Summary:
			//     Converts the numeric value of this instance to its equivalent string representation.
			//
			// Returns:
			//     The string representation of the value of this instance.
			public: override GC_PTR<string> ToString()
			{
				throw;
			}
			//
			// Summary:
			//     Converts the numeric value of this instance to its equivalent string representation
			//     using the specified culture-specific format information.
			//
			// Parameters:
			//   provider:
			//     An object that supplies culture-specific formatting information.
			//
			// Returns:
			//     The string representation of the value of this instance as specified by provider.
			public: GC_PTR<string> ToString(IFormatProvider* provider)
			{
				throw;
			}
			//
			// Summary:
			//     Converts the numeric value of this instance to its equivalent string representation,
			//     using the specified format.
			//
			// Parameters:
			//   format:
			//     A numeric format string.
			//
			// Returns:
			//     The string representation of the value of this instance as specified by format.
			//
			// Exceptions:
			//   System.FormatException:
			//     format is invalid.
			public: GC_PTR<string> ToString(string* format)
			{
				throw;
			}
			//
			// Summary:
			//     Converts the numeric value of this instance to its equivalent string representation
			//     using the specified format and culture-specific format information.
			//
			// Parameters:
			//   format:
			//     A numeric format string.
			//
			//   provider:
			//     An object that supplies culture-specific formatting information.
			//
			// Returns:
			//     The string representation of the value of this instance as specified by format
			//     and provider.
			public: GC_PTR<string> ToString(string* format, IFormatProvider* provider)
			{
				throw;
			}
			//
			// Summary:
			//     Converts the string representation of a number to its single-precision floating-point
			//     number equivalent. A return value indicates whether the conversion succeeded
			//     or failed.
			//
			// Parameters:
			//   s:
			//     A string representing a number to convert.
			//
			//   result:
			//     When this method returns, contains single-precision floating-point number
			//     equivalent to the numeric value or symbol contained in s, if the conversion
			//     succeeded, or zero if the conversion failed. The conversion fails if the
			//     s parameter is null, is not a number in a valid format, or represents a number
			//     less than System.Single.MinValue or greater than System.Single.MaxValue.
			//     This parameter is passed uninitialized.
			//
			// Returns:
			//     true if s was converted successfully; otherwise, false.
			public: static bool TryParse(string* s, float out result)
			{
				throw;
			}
			//
			// Summary:
			//     Converts the string representation of a number in a specified style and culture-specific
			//     format to its single-precision floating-point number equivalent. A return
			//     value indicates whether the conversion succeeded or failed.
			//
			// Parameters:
			//   s:
			//     A string representing a number to convert.
			//
			//   style:
			//     A bitwise combination of enumeration values that indicates the permitted
			//     format of s. A typical value to specify is System.Globalization.NumberStyles.Float
			//     combined with System.Globalization.NumberStyles.AllowThousands.
			//
			//   provider:
			//     An object that supplies culture-specific formatting information about s.
			//
			//   result:
			//     When this method returns, contains the single-precision floating-point number
			//     equivalent to the numeric value or symbol contained in s, if the conversion
			//     succeeded, or zero if the conversion failed. The conversion fails if the
			//     s parameter is null, is not in a format compliant with style, represents
			//     a number less than System.Single.MinValue or greater than System.Single.MaxValue,
			//     or if style is not a valid combination of System.Globalization.NumberStyles
			//     enumerated constants. This parameter is passed uninitialized.
			//
			// Returns:
			//     true if s was converted successfully; otherwise, false.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     style is not a System.Globalization.NumberStyles value. -or-style is the
			//     System.Globalization.NumberStyles.AllowHexSpecifier value.
			public: static bool TryParse(string* s, Globalization::NumberStyles* style, IFormatProvider* provider, float out result)
			{
				throw;
			}

			private: bool ToBoolean(IFormatProvider* provider)
			{
				throw;
			}
			private: byte ToByte(IFormatProvider* provider)
			{
				throw;
			}
			private: char ToChar(IFormatProvider* provider)
			{
				throw;
			}
			private: DateTime ToDateTime(IFormatProvider* provider)
			{
				throw;
			}
			private: decimal ToDecimal(IFormatProvider* provider)
			{
				throw;
			}
			private: double ToDouble(IFormatProvider* provider)
			{
				throw;
			}
			private: short ToInt16(IFormatProvider* provider)
			{
				throw;
			}
			private: int ToInt32(IFormatProvider* provider)
			{
				throw;
			}
			private: long long ToInt64(IFormatProvider* provider)
			{
				throw;
			}
			private: sbyte ToSByte(IFormatProvider* provider)
			{
				throw;
			}
			private: float ToSingle(IFormatProvider* provider)
			{
				throw;
			}
			private: GC_PTR<object> ToType(Type* conversionType, IFormatProvider* provider)
			{
				throw;
			}
			private: ushort ToUInt16(IFormatProvider* provider)
			{
				throw;
			}
			private: uint ToUInt32(IFormatProvider* provider)
			{
				throw;
			}
			private: ulong ToUInt64(IFormatProvider* provider)
			{
				throw;
			}
		};

		
			// Summary:
			//     Returns a value that indicates whether two specified System.Single values
			//     are not equal.
			//
			// Parameters:
			//   left:
			//     The first value to compare.
			//
			//   right:
			//     The second value to compare.
			//
			// Returns:
			//     true if left and right are not equal; otherwise, false.
			static bool operator !=(Single left, Single right);
			//
			// Summary:
			//     Returns a value that indicates whether a specified System.Single value is
			//     less than another specified System.Single value.
			//
			// Parameters:
			//   left:
			//     The first value to compare.
			//
			//   right:
			//     The second value to compare.
			//
			// Returns:
			//     true if left is less than right; otherwise, false.
			static bool operator <(Single left, Single right);
			//
			// Summary:
			//     Returns a value that indicates whether a specified System.Single value is
			//     less than or equal to another specified System.Single value.
			//
			// Parameters:
			//   left:
			//     The first value to compare.
			//
			//   right:
			//     The second value to compare.
			//
			// Returns:
			//     true if left is less than or equal to right; otherwise, false.
			static bool operator <=(Single left, Single right);
			//
			// Summary:
			//     Returns a value that indicates whether two specified System.Single values
			//     are equal.
			//
			// Parameters:
			//   left:
			//     The first value to compare.
			//
			//   right:
			//     The second value to compare.
			//
			// Returns:
			//     true if left and right are equal; otherwise, false.
			static bool operator ==(Single left, Single right);
			//
			// Summary:
			//     Returns a value that indicates whether a specified System.Single value is
			//     greater than another specified System.Single value.
			//
			// Parameters:
			//   left:
			//     The first value to compare.
			//
			//   right:
			//     The second value to compare.
			//
			// Returns:
			//     true if left is greater than right; otherwise, false.
			static bool operator >(Single left, Single right);
			//
			// Summary:
			//     Returns a value that indicates whether a specified System.Single value is
			//     greater than or equal to another specified System.Single value.
			//
			// Parameters:
			//   left:
			//     The first value to compare.
			//
			//   right:
			//     The second value to compare.
			//
			// Returns:
			//     true if left is greater than or equal to right; otherwise, false.
			static bool operator >=(Single left, Single right);
	}
}

#endif // INT32_H